// 表单详情自动抓取脚本 - 在"我的申请单"页面自动抓取表单核心信息
// 当前支持：
//   - 用印章申请表（申请事由）
//   - 借印章审批（申请事由）
//   - 采购审批表（名称、型号、配置）
//   - 采购需求表（申请事由/用途和需求内容）
//   - 财务审批表（款项用途）
//   - 出差任务审批（出差事由）
//   - 其他审批（申请内容）
//   - 大型活动费用决算表（活动名称）
//   - 大型活动预算审批表申请（活动名称）
//   - 供应商评审表（供应商1的公司名称）
//   - 装修工程需求表（现场情况介绍）
//   - 正式员工录用审批表（姓名）
//   - 续签审批表（姓名）
//   - 人员需求申请表（职位名称）
//   - 装修合同审批表（合同名称）
//   - 转正审批表（姓名）
//   - 离职审批表（姓名）
//   - 员工休假审批（休假原因内容）
// 注意：详情信息仅在控制台打印，不会修改表格显示
(function() {
    'use strict';

    // 获取主文档（如果不在iframe中，返回当前文档）
    function getMainDocument() {
        try {
            if (window.top && window.top !== window.self) {
                return window.top.document;
            }
            return document;
        } catch (e) {
            return document;
        }
    }

    // 检测是否是"我的申请单"页面
    function isMyApplicationListPage() {
        try {
            const mainDoc = getMainDocument();
            
            // 查找当前选中的 tab
            const selectedTab = mainDoc.querySelector('.tabs-selected');
            if (!selectedTab) {
                return false;
            }
            
            // 查找选中 tab 中的标题元素
            const tabTitle = selectedTab.querySelector('.tabs-title');
            if (!tabTitle) {
                return false;
            }
            
            // 获取标题文本
            const titleText = tabTitle.textContent.trim();
            
            // 检查标题是否包含"我的申请单"
            if (titleText.includes('我的申请单')) {
                return true;
            }
            
            return false;
        } catch (error) {
            // console.error('[表单详情抓取] 检测页面类型时出错:', error);
            return false;
        }
    }

    // 等待函数
    function sleep(ms) {
        return new Promise(resolve => setTimeout(resolve, ms));
    }

    // 带超时的fetch请求
    async function fetchWithTimeout(url, options = {}, timeoutMs = 25000) {
        const controller = new AbortController();
        const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
        
        try {
            const response = await fetch(url, {
                ...options,
                signal: controller.signal
            });
            clearTimeout(timeoutId);
            return response;
        } catch (error) {
            clearTimeout(timeoutId);
            if (error.name === 'AbortError') {
                throw new Error(`请求超时: 超过 ${timeoutMs}ms 未响应`);
            }
            throw error;
        }
    }

    // 轮询等待元素出现
    async function waitForElementPolling(selector, options = {}) {
        const { interval = 50, maxWait = 5000, doc = null } = options;
        const targetDoc = doc || document;
        const startTime = Date.now();
        
        while (Date.now() - startTime < maxWait) {
            const element = targetDoc.querySelector(selector);
            if (element) {
                return element;
            }
            await sleep(interval);
        }
        return null;
    }

    // 获取contextPath（从全局变量或URL推断）
    function getContextPath() {
        // 尝试从多个可能的全局变量获取
        try {
            // 尝试从window.top获取（如果是在iframe中）
            if (window.top && window.top !== window.self) {
                if (typeof window.top.contextPath !== 'undefined') {
                    return window.top.contextPath;
                }
            }
            // 尝试从当前window获取
            if (typeof contextPath !== 'undefined') {
                return contextPath;
            }
            if (typeof window.contextPath !== 'undefined') {
                return window.contextPath;
            }
        } catch (e) {
            // 跨域访问失败，继续尝试其他方式
        }
        
        // 如果全局变量不存在，尝试从URL推断
        // 从当前URL或主窗口URL推断
        let url = '';
        try {
            if (window.top && window.top !== window.self) {
                url = window.top.location.pathname;
            } else {
                url = window.location.pathname;
            }
        } catch (e) {
            url = window.location.pathname;
        }
        
        // 如果URL是 /system/... 开头，说明contextPath是 /
        // 如果URL是 /xxx/... 开头，说明contextPath是 /xxx
        // 但根据实际使用，manager接口直接跟在根路径下，所以contextPath应该是 /
        // 从HTML示例看：contextPath+"manager/approvalprocesses"
        // 如果contextPath是 /system，那么应该是 /system/manager/approvalprocesses
        // 但实际应该是 /manager/approvalprocesses，所以contextPath应该是 /
        
        // 检查URL是否包含 /system/，如果是，说明contextPath可能是 /
        if (url.startsWith('/system/')) {
            return '/';
        }
        
        // 否则尝试从路径推断（但通常manager接口在根路径下）
        const match = url.match(/^(\/[^\/]+)/);
        if (match && match[1] !== '/system') {
            return match[1];
        }
        
        // 默认返回 /（因为manager接口在根路径下）
        return '/';
    }

    // 从列表行中提取申请单信息
    function extractRowInfo(rowElement) {
        try {
            // 获取ID（从checkbox的value属性）
            const checkbox = rowElement.querySelector('input[type="checkbox"][name="id"]');
            if (!checkbox) return null;
            
            const processId = checkbox.value;
            if (!processId) return null;

            // 获取类型（从type字段的单元格）
            const typeCell = rowElement.querySelector('td[field="type"] .datagrid-cell');
            if (!typeCell) return null;
            
            const typeText = typeCell.textContent.trim();
            
            // 根据类型文本映射到type值
            let type = null;
            if (typeText === '用印章审批') {
                type = 0;
            } else if (typeText === '借印章审批') {
                type = 1;
            } else if (typeText === '采购审批表') {
                type = 32;
            } else if (typeText === '采购需求表') {
                type = 31;
            } else if (typeText === '财务审批') {
                type = 81;
            } else if (typeText === '出差任务审批') {
                type = 68;
            } else if (typeText === '其他审批') {
                type = 9;
            } else if (typeText === '大型活动费用决算表') {
                type = 42;
            } else if (typeText === '大型活动预算审批表申请') {
                type = 41;
            } else if (typeText === '供应商评审表') {
                type = 21;
            } else if (typeText === '装修工程需求表') {
                type = 21;  // 注意：与供应商评审表共用type值，但通过不同的API区分
            } else if (typeText === '正式员工录用审批表') {
                type = 62;
            } else if (typeText === '续签审批表') {
                type = 64;
            } else if (typeText === '人员需求申请表') {
                type = 61;
            } else if (typeText === '装修合同审批表') {
                type = 23;
            } else if (typeText === '转正审批表') {
                type = 63;
            } else if (typeText === '离职审批表') {
                type = 65;
            } else if (typeText === '员工休假审批') {
                type = 67;
            } else {
                // 其他类型暂不处理
                return null;
            }

            return {
                processId: processId,
                type: type,
                typeText: typeText,
                rowElement: rowElement
            };
        } catch (error) {
            // console.error('[表单详情抓取] 提取行信息时出错:', error);
            return null;
        }
    }


    // 获取用印章申请的beanId
    async function getBeanIdByProcessId(processId, type) {
        const contextPath = getContextPath();
        // 确保URL正确拼接（contextPath可能是 / 或 /xxx，需要处理）
        const baseUrl = contextPath.endsWith('/') ? contextPath.slice(0, -1) : contextPath;
        const url = `${baseUrl}/manager/approvalprocess/getBeanIdByProcessId/${processId}/${type}`;
        
        try {
            const response = await fetchWithTimeout(url, {
                method: 'GET',
                credentials: 'include'
            }, 25000); // 25秒超时
            
            if (!response.ok) {
                throw new Error(`HTTP错误: ${response.status}`);
            }
            
            const data = await response.json();
            if (data && data.handleMsg && data.handleMsg.status == 1) {
                return data.id;
            } else {
                throw new Error('获取beanId失败: ' + JSON.stringify(data));
            }
        } catch (error) {
            throw new Error(`请求失败: ${error.message}`);
        }
    }

    // 获取用印章申请的详情（申请事由）
    async function getSealApprovalDetails(beanId) {
        const contextPath = getContextPath();
        // 确保URL正确拼接（contextPath可能是 / 或 /xxx，需要处理）
        const baseUrl = contextPath.endsWith('/') ? contextPath.slice(0, -1) : contextPath;
        const url = `${baseUrl}/manager/borrowSealDetails?i=${new Date().getTime()}`;
        
        try {
            // 构建POST数据
            const formData = new URLSearchParams();
            formData.append('bid', beanId);
            
            const response = await fetchWithTimeout(url, {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/x-www-form-urlencoded'
                },
                body: formData.toString(),
                credentials: 'include'
            }, 25000); // 25秒超时
            
            if (!response.ok) {
                throw new Error(`HTTP错误: ${response.status}`);
            }
            
            const data = await response.json();
            
            // 检查响应格式（可能是分页格式 content，或 rows，或直接数组）
            let rows = null;
            if (data && data.content && Array.isArray(data.content)) {
                // 分页格式：{ content: [...], totalElements: ... }
                rows = data.content;
            } else if (data && data.rows && Array.isArray(data.rows)) {
                // 普通格式：{ rows: [...] }
                rows = data.rows;
            } else if (data && Array.isArray(data)) {
                // 直接数组格式
                rows = data;
            } else if (data && data.data && Array.isArray(data.data)) {
                // 嵌套格式：{ data: [...] }
                rows = data.data;
            }
            
            if (rows && rows.length > 0) {
                // 提取所有申请事由
                const reasons = rows
                    .map(row => {
                        // 尝试多种可能的字段名
                        return row.reasons || row.reason || row.applyReason || row.description || '';
                    })
                    .filter(r => r && r.trim())
                    .join('; ');
                
                return reasons || '';
            } else {
                return ''; // 没有详情数据
            }
        } catch (error) {
            throw new Error(`请求失败: ${error.message}`);
        }
    }

    // 获取采购审批表的详情（名称、型号、配置，如果有合同内容则拼接）
    async function getPurchaseApprovalDetails(beanId) {
        const contextPath = getContextPath();
        const baseUrl = contextPath.endsWith('/') ? contextPath.slice(0, -1) : contextPath;
        
        try {
            // 1. 获取采购内容详情（名称、型号、配置）
            const contentsUrl = `${baseUrl}/manager/purchaseContents?i=${new Date().getTime()}`;
            const formData = new URLSearchParams();
            formData.append('bid', beanId);
            
            const contentsResponse = await fetchWithTimeout(contentsUrl, {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/x-www-form-urlencoded'
                },
                body: formData.toString(),
                credentials: 'include'
            }, 25000); // 25秒超时
            
            if (!contentsResponse.ok) {
                throw new Error(`HTTP错误: ${contentsResponse.status}`);
            }
            
            const contentsData = await contentsResponse.json();
            
            // 检查响应格式
            let rows = null;
            if (contentsData && contentsData.content && Array.isArray(contentsData.content)) {
                rows = contentsData.content;
            } else if (contentsData && contentsData.rows && Array.isArray(contentsData.rows)) {
                rows = contentsData.rows;
            } else if (contentsData && Array.isArray(contentsData)) {
                rows = contentsData;
            } else if (contentsData && contentsData.data && Array.isArray(contentsData.data)) {
                rows = contentsData.data;
            }
            
            // 提取所有"名称、型号、配置"字段的内容
            let details = '';
            if (rows && rows.length > 0) {
                const contents = rows
                    .map(row => {
                        // 字段名可能是 content
                        return row.content || '';
                    })
                    .filter(c => c && c.trim())
                    .join('; ');
                
                details = contents || '';
            }
            
            // 2. 获取采购审批表主信息，检查是否有合同内容字段
            try {
                const approvalUrl = `${baseUrl}/manager/purchaseApproval/${beanId}?i=${new Date().getTime()}`;
                const approvalResponse = await fetchWithTimeout(approvalUrl, {
                    method: 'GET',
                    credentials: 'include'
                }, 25000); // 25秒超时
                
                if (approvalResponse.ok) {
                    const approvalData = await approvalResponse.json();
                    
                    // 检查是否有合同内容字段（字段名可能是 content）
                    if (approvalData && approvalData.content && approvalData.content.trim()) {
                        const contractContent = approvalData.content.trim();
                        // 如果有详情内容，则拼接；否则直接使用合同内容
                        if (details) {
                            details = `${details}; ${contractContent}`;
                        } else {
                            details = `${contractContent}`;
                        }
                    }
                }
            } catch (approvalError) {
                // 如果获取合同内容失败，不影响主流程，只记录警告
                // console.warn('[表单详情抓取] 获取合同内容失败:', approvalError.message);
            }
            
            return details || '';
        } catch (error) {
            throw new Error(`请求失败: ${error.message}`);
        }
    }

    // 获取采购需求表的详情（申请事由/用途和需求内容）
    async function getPurchaseRequestDetails(beanId) {
        const contextPath = getContextPath();
        const baseUrl = contextPath.endsWith('/') ? contextPath.slice(0, -1) : contextPath;
        const url = `${baseUrl}/manager/purchaseNeeds/${beanId}?i=${new Date().getTime()}`;
        
        try {
            const response = await fetchWithTimeout(url, {
                method: 'GET',
                credentials: 'include'
            }, 25000); // 25秒超时
            
            if (!response.ok) {
                throw new Error(`HTTP错误: ${response.status}`);
            }
            
            const data = await response.json();
            
            if (data) {
                // 提取申请事由/用途和需求内容
                const intendedUse = data.intendedUse || '';
                const needsContent = data.needsContent || '';
                
                // 拼接两个字段
                const parts = [];
                if (intendedUse && intendedUse.trim()) {
                    parts.push(intendedUse.trim());
                }
                if (needsContent && needsContent.trim()) {
                    parts.push(needsContent.trim());
                }
                
                return parts.join('; ') || '';
            } else {
                return ''; // 没有详情数据
            }
        } catch (error) {
            throw new Error(`请求失败: ${error.message}`);
        }
    }

    // 获取出差任务审批的详情（出差事由）
    async function getBusinessTripDetails(beanId) {
        const contextPath = getContextPath();
        const baseUrl = contextPath.endsWith('/') ? contextPath.slice(0, -1) : contextPath;
        const url = `${baseUrl}/manager/businessMissi/${beanId}?i=${new Date().getTime()}`;
        
        try {
            const response = await fetchWithTimeout(url, {
                method: 'GET',
                credentials: 'include'
            }, 25000); // 25秒超时
            
            if (!response.ok) {
                throw new Error(`HTTP错误: ${response.status}`);
            }
            
            const data = await response.json();
            
            if (data) {
                // 提取出差事由
                const visitingReson = data.visitingReson || '';
                return visitingReson.trim() || '';
            } else {
                return ''; // 没有详情数据
            }
        } catch (error) {
            throw new Error(`请求失败: ${error.message}`);
        }
    }

    // 获取其他审批的详情（申请内容）
    async function getOtherApprovalDetails(beanId) {
        const contextPath = getContextPath();
        const baseUrl = contextPath.endsWith('/') ? contextPath.slice(0, -1) : contextPath;
        const url = `${baseUrl}/manager/otherApproval/${beanId}?i=${new Date().getTime()}`;
        
        try {
            const response = await fetchWithTimeout(url, {
                method: 'GET',
                credentials: 'include'
            }, 25000); // 25秒超时
            
            if (!response.ok) {
                throw new Error(`HTTP错误: ${response.status}`);
            }
            
            const data = await response.json();
            
            if (data) {
                // 提取申请内容
                const appContent = data.appContent || '';
                return appContent.trim() || '';
            } else {
                return ''; // 没有详情数据
            }
        } catch (error) {
            throw new Error(`请求失败: ${error.message}`);
        }
    }

    // 获取大型活动费用决算表的详情（活动名称）
    async function getActivityAccountDetails(beanId) {
        const contextPath = getContextPath();
        const baseUrl = contextPath.endsWith('/') ? contextPath.slice(0, -1) : contextPath;
        const url = `${baseUrl}/manager/activityAccountApproval/${beanId}?i=${new Date().getTime()}`;
        
        try {
            const response = await fetchWithTimeout(url, {
                method: 'GET',
                credentials: 'include'
            }, 25000); // 25秒超时
            
            if (!response.ok) {
                throw new Error(`HTTP错误: ${response.status}`);
            }
            
            const data = await response.json();
            
            if (data) {
                // 提取活动名称
                const activityName = data.activityName || '';
                return activityName.trim() || '';
            } else {
                return ''; // 没有详情数据
            }
        } catch (error) {
            throw new Error(`请求失败: ${error.message}`);
        }
    }

    // 获取大型活动预算审批表申请的详情（活动名称）
    async function getActivityBudgetDetails(beanId) {
        const contextPath = getContextPath();
        const baseUrl = contextPath.endsWith('/') ? contextPath.slice(0, -1) : contextPath;
        const url = `${baseUrl}/manager/activityBudgetApproval/${beanId}?i=${new Date().getTime()}`;
        
        try {
            const response = await fetchWithTimeout(url, {
                method: 'GET',
                credentials: 'include'
            }, 25000); // 25秒超时
            
            if (!response.ok) {
                throw new Error(`HTTP错误: ${response.status}`);
            }
            
            const data = await response.json();
            
            if (data) {
                // 提取活动名称
                const activityName = data.activityName || '';
                return activityName.trim() || '';
            } else {
                return ''; // 没有详情数据
            }
        } catch (error) {
            throw new Error(`请求失败: ${error.message}`);
        }
    }

    // 获取供应商评审表的详情（供应商1的公司名称）
    async function getProjectSupplierDetails(beanId) {
        const contextPath = getContextPath();
        const baseUrl = contextPath.endsWith('/') ? contextPath.slice(0, -1) : contextPath;
        const url = `${baseUrl}/manager/projectSupplier/${beanId}?i=${new Date().getTime()}`;
        
        try {
            const response = await fetchWithTimeout(url, {
                method: 'GET',
                credentials: 'include'
            }, 25000); // 25秒超时
            
            if (!response.ok) {
                throw new Error(`HTTP错误: ${response.status}`);
            }
            
            const data = await response.json();
            
            if (data) {
                // 提取供应商1的公司名称
                const companyName = data.companyname1 || '';
                return companyName.trim() || '';
            } else {
                return ''; // 没有详情数据
            }
        } catch (error) {
            throw new Error(`请求失败: ${error.message}`);
        }
    }

    // 获取借印章审批的详情（申请事由）
    async function getBorrowSealDetails(beanId) {
        const contextPath = getContextPath();
        const baseUrl = contextPath.endsWith('/') ? contextPath.slice(0, -1) : contextPath;
        const url = `${baseUrl}/manager/borrowSealDetails?i=${new Date().getTime()}`;
        
        try {
            // 构建POST数据
            const formData = new URLSearchParams();
            formData.append('bid', beanId);
            
            const response = await fetchWithTimeout(url, {
                method: 'POST',
                headers: {
                    'Content-Type': 'application/x-www-form-urlencoded'
                },
                body: formData.toString(),
                credentials: 'include'
            }, 25000); // 25秒超时
            
            if (!response.ok) {
                throw new Error(`HTTP错误: ${response.status}`);
            }
            
            const data = await response.json();
            
            // 检查响应格式（可能是分页格式 content，或 rows，或直接数组）
            let rows = null;
            if (data && data.content && Array.isArray(data.content)) {
                rows = data.content;
            } else if (data && data.rows && Array.isArray(data.rows)) {
                rows = data.rows;
            } else if (data && Array.isArray(data)) {
                rows = data;
            } else if (data && data.data && Array.isArray(data.data)) {
                rows = data.data;
            }
            
            if (rows && rows.length > 0) {
                // 提取所有申请事由
                const reasons = rows
                    .map(row => {
                        // 尝试多种可能的字段名
                        return row.reasons || row.reason || row.applyReason || row.description || '';
                    })
                    .filter(r => r && r.trim())
                    .join('; ');
                
                return reasons || '';
            } else {
                return ''; // 没有详情数据
            }
        } catch (error) {
            throw new Error(`请求失败: ${error.message}`);
        }
    }

    // 获取装修工程需求表的详情（现场情况介绍）
    async function getDecorateProjectDetails(beanId) {
        const contextPath = getContextPath();
        const baseUrl = contextPath.endsWith('/') ? contextPath.slice(0, -1) : contextPath;
        const url = `${baseUrl}/manager/decorateProject/${beanId}?i=${new Date().getTime()}`;
        
        try {
            const response = await fetchWithTimeout(url, {
                method: 'GET',
                credentials: 'include'
            }, 25000); // 25秒超时
            
            if (!response.ok) {
                throw new Error(`HTTP错误: ${response.status}`);
            }
            
            const data = await response.json();
            
            if (data) {
                // 提取现场情况介绍
                const presentation = data.presentation || '';
                return presentation.trim() || '';
            } else {
                return ''; // 没有详情数据
            }
        } catch (error) {
            throw new Error(`请求失败: ${error.message}`);
        }
    }

    // 获取正式员工录用审批表的详情（姓名）
    async function getPersonRecruitmentDetails(beanId) {
        const contextPath = getContextPath();
        const baseUrl = contextPath.endsWith('/') ? contextPath.slice(0, -1) : contextPath;
        const url = `${baseUrl}/manager/personRecruitment/${beanId}?i=${new Date().getTime()}`;
        
        try {
            const response = await fetchWithTimeout(url, {
                method: 'GET',
                credentials: 'include'
            }, 25000); // 25秒超时
            
            if (!response.ok) {
                throw new Error(`HTTP错误: ${response.status}`);
            }
            
            const data = await response.json();
            
            if (data) {
                // 提取姓名
                const name = data.name || '';
                return name.trim() || '';
            } else {
                return ''; // 没有详情数据
            }
        } catch (error) {
            throw new Error(`请求失败: ${error.message}`);
        }
    }

    // 获取续签审批表的详情（姓名）
    async function getPersonRenewDetails(beanId) {
        const contextPath = getContextPath();
        const baseUrl = contextPath.endsWith('/') ? contextPath.slice(0, -1) : contextPath;
        const url = `${baseUrl}/manager/personRenew/${beanId}?i=${new Date().getTime()}`;
        
        try {
            const response = await fetchWithTimeout(url, {
                method: 'GET',
                credentials: 'include'
            }, 25000); // 25秒超时
            
            if (!response.ok) {
                throw new Error(`HTTP错误: ${response.status}`);
            }
            
            const data = await response.json();
            
            if (data) {
                // 提取姓名
                const name = data.name || '';
                return name.trim() || '';
            } else {
                return ''; // 没有详情数据
            }
        } catch (error) {
            throw new Error(`请求失败: ${error.message}`);
        }
    }

    // 获取人员需求申请表的详情（职位名称）
    async function getPersonRequirementDetails(beanId) {
        const contextPath = getContextPath();
        const baseUrl = contextPath.endsWith('/') ? contextPath.slice(0, -1) : contextPath;
        const url = `${baseUrl}/manager/personRequirement/${beanId}?i=${new Date().getTime()}`;
        
        try {
            const response = await fetchWithTimeout(url, {
                method: 'GET',
                credentials: 'include'
            }, 25000); // 25秒超时
            
            if (!response.ok) {
                throw new Error(`HTTP错误: ${response.status}`);
            }
            
            const data = await response.json();
            
            if (data) {
                // 提取职位名称
                const jobTitle = data.jobTitle || '';
                return jobTitle.trim() || '';
            } else {
                return ''; // 没有详情数据
            }
        } catch (error) {
            throw new Error(`请求失败: ${error.message}`);
        }
    }

    // 获取装修合同审批表的详情（合同名称）
    async function getDecorateContractDetails(beanId) {
        const contextPath = getContextPath();
        const baseUrl = contextPath.endsWith('/') ? contextPath.slice(0, -1) : contextPath;
        const url = `${baseUrl}/manager/decorateContract/${beanId}?i=${new Date().getTime()}`;
        
        try {
            const response = await fetchWithTimeout(url, {
                method: 'GET',
                credentials: 'include'
            }, 25000); // 25秒超时
            
            if (!response.ok) {
                throw new Error(`HTTP错误: ${response.status}`);
            }
            
            const data = await response.json();
            
            if (data) {
                // 提取合同名称
                const contractName = data.contractName || '';
                return contractName.trim() || '';
            } else {
                return ''; // 没有详情数据
            }
        } catch (error) {
            throw new Error(`请求失败: ${error.message}`);
        }
    }

    // 获取转正审批表的详情（姓名）
    async function getPersonPositiveDetails(beanId) {
        const contextPath = getContextPath();
        const baseUrl = contextPath.endsWith('/') ? contextPath.slice(0, -1) : contextPath;
        const url = `${baseUrl}/manager/personPositive/${beanId}?i=${new Date().getTime()}`;
        
        try {
            const response = await fetchWithTimeout(url, {
                method: 'GET',
                credentials: 'include'
            }, 25000); // 25秒超时
            
            if (!response.ok) {
                throw new Error(`HTTP错误: ${response.status}`);
            }
            
            const data = await response.json();
            
            if (data) {
                // 提取姓名
                const name = data.name || '';
                return name.trim() || '';
            } else {
                return ''; // 没有详情数据
            }
        } catch (error) {
            throw new Error(`请求失败: ${error.message}`);
        }
    }

    // 获取离职审批表的详情（姓名）
    async function getPersonDepartureDetails(beanId) {
        const contextPath = getContextPath();
        const baseUrl = contextPath.endsWith('/') ? contextPath.slice(0, -1) : contextPath;
        const url = `${baseUrl}/manager/personDeparture/${beanId}?i=${new Date().getTime()}`;
        
        try {
            const response = await fetchWithTimeout(url, {
                method: 'GET',
                credentials: 'include'
            }, 25000); // 25秒超时
            
            if (!response.ok) {
                throw new Error(`HTTP错误: ${response.status}`);
            }
            
            const data = await response.json();
            
            if (data) {
                // 提取姓名
                const name = data.name || '';
                return name.trim() || '';
            } else {
                return ''; // 没有详情数据
            }
        } catch (error) {
            throw new Error(`请求失败: ${error.message}`);
        }
    }

    // 获取员工休假审批的详情（休假原因内容）
    async function getEmployeeLeaveDetails(beanId) {
        const contextPath = getContextPath();
        const baseUrl = contextPath.endsWith('/') ? contextPath.slice(0, -1) : contextPath;
        const url = `${baseUrl}/managerEmp/employeeLeaveApply_add/${beanId}?i=${new Date().getTime()}`;
        
        try {
            const response = await fetchWithTimeout(url, {
                method: 'GET',
                credentials: 'include'
            }, 25000); // 25秒超时
            
            if (!response.ok) {
                throw new Error(`HTTP错误: ${response.status}`);
            }
            
            const data = await response.json();
            
            if (data) {
                // 提取休假原因内容
                const vacationReasons = data.vacationReasons || '';
                return vacationReasons.trim() || '';
            } else {
                return ''; // 没有详情数据
            }
        } catch (error) {
            throw new Error(`请求失败: ${error.message}`);
        }
    }

    // 获取财务审批表的详情（根据报销单类型选择字段）
    async function getFinanceApprovalDetails(beanId) {
        const contextPath = getContextPath();
        const baseUrl = contextPath.endsWith('/') ? contextPath.slice(0, -1) : contextPath;
        const url = `${baseUrl}/manager/financeApproval/${beanId}?i=${new Date().getTime()}`;
        
        try {
            const response = await fetchWithTimeout(url, {
                method: 'GET',
                credentials: 'include'
            }, 25000); // 25秒超时
            
            if (!response.ok) {
                throw new Error(`HTTP错误: ${response.status}`);
            }
            
            const data = await response.json();
            
            if (data) {
                // 根据报销单类型(rbType)选择不同的字段
                // rbType == 1: 支出凭单，使用 paymentContent (款项用途)
                // rbType != 1: 差旅费报销单，使用 businessCase (出差事由)
                const rbType = data.rbType;
                let detailValue = '';
                let detailLabel = '';
                
                if (rbType == 1) {
                    // 支出凭单
                    const paymentContent = data.paymentContent || '';
                    const payCompany = data.payCompany || '';
                    
                    // 拼接款项用途和收款单位
                    const parts = [];
                    if (paymentContent && paymentContent.trim()) {
                        parts.push(paymentContent.trim());
                    }
                    if (payCompany && payCompany.trim()) {
                        parts.push(payCompany.trim());
                    }
                    
                    detailValue = parts.join('; ');
                    detailLabel = '款项用途';
                } else {
                    // 差旅费报销单
                    detailValue = data.businessCase || '';
                    detailLabel = '出差事由';
                }
                
                return {
                    value: detailValue.trim() || '',
                    label: detailLabel
                };
            } else {
                return {
                    value: '',
                    label: '款项用途'
                };
            }
        } catch (error) {
            throw new Error(`请求失败: ${error.message}`);
        }
    }

    // 在列表行中替换"申请部门"列的内容为详情
    function addDetailsColumn(rowInfo, details = '') {
        try {
            const rowElement = rowInfo.rowElement;
            
            // 查找"申请部门"列（field="applyDept.deptname"）
            const deptCell = rowElement.querySelector('td[field="applyDept.deptname"]');
            if (!deptCell) return;

            // 查找单元格内的div元素
            const cellDiv = deptCell.querySelector('.datagrid-cell');
            if (!cellDiv) return;

            // 替换内容为详情
            cellDiv.textContent = details || '';
            cellDiv.title = details || ''; // 设置title，鼠标悬停时显示完整内容
            
            // 确保样式正确（单行显示，超出省略号）
            // 使用单独的样式属性设置，避免覆盖其他样式
            if (!cellDiv.style.whiteSpace) {
                cellDiv.style.whiteSpace = 'nowrap';
            }
            if (!cellDiv.style.overflow) {
                cellDiv.style.overflow = 'hidden';
            }
            if (!cellDiv.style.textOverflow) {
                cellDiv.style.textOverflow = 'ellipsis';
            }
            
        } catch (error) {
            // console.error('[表单详情抓取] 替换申请部门列内容时出错:', error);
        }
    }

    // 添加全局CSS样式，确保"申请部门"列（现在显示详情）能正确显示
    function addDetailsColumnStyle(targetDoc = null) {
        try {
            const doc = targetDoc || getMainDocument();
            const styleId = 'oa-details-column-style';
            
            // 检查是否已经添加过样式
            if (doc.getElementById(styleId)) {
                return;
            }
            
            // 创建style元素
            const style = doc.createElement('style');
            style.id = styleId;
            style.type = 'text/css';
            // 确保"申请部门"列（field="applyDept.deptname"）能正确显示详情内容
            style.textContent = `
                td[field="applyDept.deptname"] .datagrid-cell {
                    white-space: nowrap;
                    overflow: hidden;
                    text-overflow: ellipsis;
                    cursor: pointer !important;
                }
                td[field="applyDept.deptname"] .datagrid-cell:hover {
                    color: #1890ff;
                }
            `;
            
            // 添加到head或body
            const head = doc.head || doc.getElementsByTagName('head')[0];
            if (head) {
                head.appendChild(style);
            } else {
                doc.body.appendChild(style);
            }
        } catch (error) {
            // console.error('[表单详情抓取] 添加样式时出错:', error);
        }
    }

    // 将表头的"申请部门"标题改为"详情"，并添加刷新按钮
    function addDetailsHeader(targetDoc = null) {
        try {
            const doc = targetDoc || getMainDocument();
            
            // 先添加全局样式
            addDetailsColumnStyle(doc);
            
            const headerRow = doc.querySelector('.datagrid-header-row');
            if (!headerRow) return;

            // 查找"申请部门"列标题（field="applyDept.deptname"）
            const deptHeader = doc.querySelector('td[field="applyDept.deptname"]');
            if (!deptHeader) return;

            // 查找表头内的span元素
            const headerSpan = deptHeader.querySelector('.datagrid-cell span');
            if (!headerSpan) return;
            
            // 检查是否已经添加过点击事件（避免重复添加）
            if (deptHeader.dataset.oaRefreshAdded) {
                return;
            }
            deptHeader.dataset.oaRefreshAdded = 'true';
            
            // 将标题改为"详情 ⟳"（添加刷新图标）
            headerSpan.innerHTML = '详情 <span style="font-size:12px;margin-left:4px;display:inline-block;">⟳</span>';
            
            // 让整个表头单元格可点击
            const headerCell = deptHeader.querySelector('.datagrid-cell');
            if (headerCell) {
                headerCell.style.cursor = 'pointer';
                headerCell.title = '点击刷新表单详情';
                
                // 绑定点击事件到整个单元格
                headerCell.addEventListener('click', async (e) => {
                    e.preventDefault();
                    e.stopPropagation();
                    
                    // console.log('[表单详情抓取] 手动触发详情加载...');
                    
                    const iconSpan = headerSpan.querySelector('span span');
                    
                    // 改变图标为打勾（✓）
                    if (iconSpan) {
                        iconSpan.textContent = '✓';
                        iconSpan.style.color = '#52c41a'; // 绿色
                    }
                    
                    // 清除已处理标记，强制重新加载
                    processedRows.clear();
                    
                    // 调用处理函数
                    try {
                        await processAllRows();
                        // console.log('[表单详情抓取] 手动加载完成');
                    } catch (error) {
                        // console.error('[表单详情抓取] 手动加载失败:', error);
                    } finally {
                        // 加载完成后（无论成功或失败），延迟500ms后变回刷新图标
                        setTimeout(() => {
                            if (iconSpan) {
                                iconSpan.textContent = '⟳';
                                iconSpan.style.color = '';
                            }
                        }, 500);
                    }
                });
            }
            
        } catch (error) {
            // console.error('[表单详情抓取] 修改表头时出错:', error);
        }
    }

    // 处理单行数据
    async function processRow(rowInfo) {
        try {
            // 只处理支持的审批类型
            if (rowInfo.type !== 0 && rowInfo.type !== 1 && rowInfo.type !== 21 && rowInfo.type !== 23 && 
                rowInfo.type !== 31 && rowInfo.type !== 32 && rowInfo.type !== 41 && rowInfo.type !== 42 && 
                rowInfo.type !== 61 && rowInfo.type !== 62 && rowInfo.type !== 63 && rowInfo.type !== 64 && 
                rowInfo.type !== 65 && rowInfo.type !== 67 && rowInfo.type !== 68 && rowInfo.type !== 81 && rowInfo.type !== 9) {
                return;
            }

            // console.log(`[表单详情抓取] 开始处理行: processId=${rowInfo.processId}, type=${rowInfo.typeText}`);

            // 获取beanId
            const beanId = await getBeanIdByProcessId(rowInfo.processId, rowInfo.type);
            if (!beanId) {
                // console.warn(`[表单详情抓取] 无法获取beanId: processId=${rowInfo.processId}`);
                return;
            }

            // console.log(`[表单详情抓取] 获取到beanId: ${beanId}`);

            // 根据类型获取不同的详情
            let details = '';
            let detailLabel = '';
            
            if (rowInfo.type === 0) {
                // 用印章审批
                details = await getSealApprovalDetails(beanId);
                detailLabel = '申请事由';
            } else if (rowInfo.type === 1) {
                // 借印章审批
                details = await getBorrowSealDetails(beanId);
                detailLabel = '申请事由';
            } else if (rowInfo.type === 21) {
                // type=21需要区分供应商评审表和装修工程需求表
                if (rowInfo.typeText === '供应商评审表') {
                    details = await getProjectSupplierDetails(beanId);
                    detailLabel = '供应商1的公司名称';
                } else if (rowInfo.typeText === '装修工程需求表') {
                    details = await getDecorateProjectDetails(beanId);
                    detailLabel = '现场情况介绍';
                }
            } else if (rowInfo.type === 23) {
                // 装修合同审批表
                details = await getDecorateContractDetails(beanId);
                detailLabel = '合同名称';
            } else if (rowInfo.type === 32) {
                // 采购审批表
                details = await getPurchaseApprovalDetails(beanId);
                detailLabel = '名称、型号、配置';
            } else if (rowInfo.type === 31) {
                // 采购需求表
                details = await getPurchaseRequestDetails(beanId);
                detailLabel = '申请事由/用途和需求内容';
            } else if (rowInfo.type === 41) {
                // 大型活动预算审批表申请
                details = await getActivityBudgetDetails(beanId);
                detailLabel = '活动名称';
            } else if (rowInfo.type === 81) {
                // 财务审批表
                const detailResult = await getFinanceApprovalDetails(beanId);
                // getFinanceApprovalDetails 返回 {value, label} 对象
                if (typeof detailResult === 'object' && detailResult !== null) {
                    details = detailResult.value || '';
                    detailLabel = detailResult.label || '款项用途';
                } else {
                    // 兼容旧格式（字符串）
                    details = detailResult || '';
                    detailLabel = '款项用途';
                }
            } else if (rowInfo.type === 68) {
                // 出差任务审批
                details = await getBusinessTripDetails(beanId);
                detailLabel = '出差事由';
            } else if (rowInfo.type === 9) {
                // 其他审批
                details = await getOtherApprovalDetails(beanId);
                detailLabel = '申请内容';
            } else if (rowInfo.type === 42) {
                // 大型活动费用决算表
                details = await getActivityAccountDetails(beanId);
                detailLabel = '活动名称';
            } else if (rowInfo.type === 61) {
                // 人员需求申请表
                details = await getPersonRequirementDetails(beanId);
                detailLabel = '职位名称';
            } else if (rowInfo.type === 62) {
                // 正式员工录用审批表
                details = await getPersonRecruitmentDetails(beanId);
                detailLabel = '姓名';
            } else if (rowInfo.type === 63) {
                // 转正审批表
                details = await getPersonPositiveDetails(beanId);
                detailLabel = '姓名';
            } else if (rowInfo.type === 64) {
                // 续签审批表
                details = await getPersonRenewDetails(beanId);
                detailLabel = '姓名';
            } else if (rowInfo.type === 65) {
                // 离职审批表
                details = await getPersonDepartureDetails(beanId);
                detailLabel = '姓名';
            } else if (rowInfo.type === 67) {
                // 员工休假审批
                details = await getEmployeeLeaveDetails(beanId);
                detailLabel = '休假原因内容';
            }
            
            // 在控制台打印关键详情
            // console.log(`[表单详情抓取] ===== 申请单详情 =====`);
            // console.log(`类型: ${rowInfo.typeText}`);
            // console.log(`ProcessId: ${rowInfo.processId}`);
            // console.log(`BeanId: ${beanId}`);
            // console.log(`${detailLabel}: ${details || '(无)'}`);
            // console.log(`[表单详情抓取] ====================`);
            
            // 将详情添加到表格中
            addDetailsColumn(rowInfo, details);
            
        } catch (error) {
            // 区分超时错误和其他错误
            const errorMessage = error.message || String(error);
            if (errorMessage.includes('超时') || errorMessage.includes('timeout')) {
                // console.warn(`[表单详情抓取] 请求超时 (processId=${rowInfo.processId}): ${errorMessage}`);
            } else {
                // console.error(`[表单详情抓取] 处理行数据时出错 (processId=${rowInfo.processId}):`, error);
            }
        }
    }

    // 在文档中查找表格（包括iframe）
    function findTableInDocument(doc) {
        // 先尝试在当前文档中查找
        let rows = doc.querySelectorAll('.datagrid-btable tbody tr.datagrid-row');
        if (rows.length > 0) {
            return { rows: Array.from(rows), doc: doc };
        }
        
        // 尝试其他选择器
        rows = doc.querySelectorAll('tr.datagrid-row');
        if (rows.length > 0) {
            return { rows: Array.from(rows), doc: doc };
        }
        
        // 尝试更宽泛的选择器
        rows = doc.querySelectorAll('.datagrid-btable tbody tr');
        if (rows.length > 0) {
            // 过滤掉只有行号的tr
            const validRows = Array.from(rows).filter(tr => {
                const checkbox = tr.querySelector('input[type="checkbox"][name="id"]');
                return checkbox && checkbox.value;
            });
            if (validRows.length > 0) {
                return { rows: validRows, doc: doc };
            }
        }
        
        return null;
    }

    // 查找所有iframe并尝试在其中查找表格
    function findTableInIframes(mainDoc) {
        const iframes = mainDoc.querySelectorAll('iframe');
        for (const iframe of iframes) {
            try {
                const iframeDoc = iframe.contentDocument || iframe.contentWindow?.document;
                if (iframeDoc) {
                    const result = findTableInDocument(iframeDoc);
                    if (result) {
                        return result;
                    }
                }
            } catch (e) {
                // 跨域iframe无法访问，跳过
                continue;
            }
        }
        return null;
    }

    // 处理状态标记
    let isProcessing = false;
    let processedRows = new Set(); // 记录已处理的行ID

    // 处理所有列表行
    async function processAllRows() {
        // 防止重复处理
        if (isProcessing) {
            return;
        }
        
        try {
            isProcessing = true;
            
            const mainDoc = getMainDocument();
            
            // 先尝试在主文档中查找
            let result = findTableInDocument(mainDoc);
            
            // 如果主文档中找不到，尝试在iframe中查找
            if (!result) {
                result = findTableInIframes(mainDoc);
            }
            
            // 如果还是找不到，等待一下再试（可能表格还在加载）
            if (!result) {
                await sleep(1000);
                result = findTableInDocument(mainDoc);
                if (!result) {
                    result = findTableInIframes(mainDoc);
                }
            }

            if (!result || result.rows.length === 0) {
                // console.log('[表单详情抓取] 未找到列表行');
                return;
            }
            
            // 确保表头已添加（在"表单类型"列之后）
            addDetailsHeader(result.doc || mainDoc);

            const { rows } = result;

            // 提取每行的信息
            const rowInfos = [];
            rows.forEach(row => {
                const info = extractRowInfo(row);
                if (info) {
                    rowInfos.push(info);
                }
            });

            // 只处理支持的审批类型（获取详情）
            const supportedRows = rowInfos.filter(info => 
                info.type === 0 || info.type === 1 || info.type === 21 || info.type === 23 || 
                info.type === 31 || info.type === 32 || info.type === 41 || info.type === 42 || 
                info.type === 61 || info.type === 62 || info.type === 63 || info.type === 64 || 
                info.type === 65 || info.type === 67 || info.type === 68 || info.type === 81 || info.type === 9
            );
            
            // 过滤掉已经处理过的行（只检查已处理标记）
            const newRows = supportedRows.filter(info => {
                // 如果不在已处理列表中，则需要处理
                return !processedRows.has(info.processId);
            });
            
            if (newRows.length > 0) {
                const typeNames = newRows.map(r => r.typeText).join('、');
                // console.log(`[表单详情抓取] 找到 ${newRows.length} 行新的审批记录（${typeNames}），开始并行抓取详情...`);

                // 并行处理所有申请单行，提高处理速度
                const promises = newRows.map(async (rowInfo) => {
                    try {
                        await processRow(rowInfo);
                        // 标记为已处理
                        processedRows.add(rowInfo.processId);
                    } catch (error) {
                        // console.error(`[表单详情抓取] 处理行 ${rowInfo.processId} 时出错:`, error);
                        // 即使出错也继续处理其他行
                    }
                });

                // 等待所有并行任务完成
                await Promise.allSettled(promises);

                // console.log(`[表单详情抓取] 处理完成，已处理 ${newRows.length} 行`);
            }
            
        } catch (error) {
            // console.error('[表单详情抓取] 处理所有行时出错:', error);
        } finally {
            isProcessing = false;
        }
    }

    // 监听表格数据变化（使用MutationObserver）
    let tableObserver = null;
    let lastRowCount = 0;
    let lastRowIds = new Set(); // 记录上一页的行ID集合
    let paginationHandlers = []; // 存储分页事件处理器，用于清理
    
    // 处理翻页后的数据抓取
    function handlePageChange() {
        // console.log('[表单详情抓取] 检测到翻页，准备抓取新页面的数据...');
        // 清除当前页面的已处理标记（基于当前可见的行）
        const mainDoc = getMainDocument();
        let result = findTableInDocument(mainDoc);
        if (!result) {
            result = findTableInIframes(mainDoc);
        }
        
        if (result && result.rows.length > 0) {
            // 确保表头已添加（在"表单类型"列之后）
            addDetailsHeader(result.doc || mainDoc);
            
            // 获取当前页面的所有processId
            const currentPageIds = new Set();
            result.rows.forEach(row => {
                const checkbox = row.querySelector('input[type="checkbox"][name="id"]');
                if (checkbox && checkbox.value) {
                    currentPageIds.add(checkbox.value);
                }
            });
            
            // 只清除当前页面的已处理标记（如果该行不在当前页面，则保留标记）
            // 这样可以避免重复处理之前已经处理过的行
            // 但为了确保翻页后能处理新页面的行，我们清除所有不在当前页面的标记
            // 实际上，翻页后应该清除所有标记，因为新页面的行都是新的
            processedRows.clear();
            
            // 延迟处理，等待DOM完全更新
            setTimeout(() => {
                if (!isProcessing) {
                    processAllRows();
                }
            }, 800); // 增加延迟时间，确保翻页后的数据完全加载
        }
    }
    
    // 监听分页按钮点击事件
    function observePaginationButtons(targetDoc) {
        try {
            // 查找分页容器
            const paginationContainer = targetDoc.querySelector('.datagrid-pager.pagination');
            if (!paginationContainer) {
                return;
            }
            
            // 清除之前的事件处理器
            paginationHandlers.forEach(handler => {
                if (handler.element && handler.event) {
                    handler.element.removeEventListener(handler.event, handler.callback);
                }
            });
            paginationHandlers = [];
            
            // 使用事件委托监听所有分页按钮（更可靠）
            const handlePaginationClick = (e) => {
                const target = e.target;
                // 检查是否点击了分页按钮
                const paginationBtn = target.closest('.pagination-first, .pagination-prev, .pagination-next, .pagination-last, .pagination-load');
                if (paginationBtn) {
                    // 如果按钮被禁用，不处理（但刷新按钮不受此限制）
                    const btn = paginationBtn.closest('a');
                    if (btn && (paginationBtn.classList.contains('pagination-load') || !btn.classList.contains('l-btn-disabled'))) {
                        // console.log('[表单详情抓取] 检测到分页按钮点击');
                        handlePageChange();
                    }
                }
            };
            
            paginationContainer.addEventListener('click', handlePaginationClick, true);
            paginationHandlers.push({ element: paginationContainer, event: 'click', callback: handlePaginationClick });
            
            // 单独监听刷新按钮（pagination-load）
            const refreshBtn = paginationContainer.querySelector('.pagination-load');
            if (refreshBtn) {
                const btn = refreshBtn.closest('a');
                if (btn) {
                    const handler = (e) => {
                        // console.log('[表单详情抓取] 检测到刷新按钮点击');
                        handlePageChange();
                    };
                    btn.addEventListener('click', handler);
                    paginationHandlers.push({ element: btn, event: 'click', callback: handler });
                }
            }
            
            // 监听页码输入框变化
            const pageNumInput = paginationContainer.querySelector('.pagination-num');
            if (pageNumInput) {
                const handler = (e) => {
                    // 延迟处理，等待用户输入完成（可能按回车或失去焦点）
                    setTimeout(() => {
                        handlePageChange();
                    }, 500);
                };
                pageNumInput.addEventListener('change', handler);
                pageNumInput.addEventListener('blur', handler);
                // 监听回车键
                pageNumInput.addEventListener('keydown', (e) => {
                    if (e.key === 'Enter') {
                        setTimeout(() => {
                            handlePageChange();
                        }, 500);
                    }
                });
                paginationHandlers.push({ element: pageNumInput, event: 'change', callback: handler });
                paginationHandlers.push({ element: pageNumInput, event: 'blur', callback: handler });
            }
            
            // 监听每页显示数量变化
            const pageSizeSelect = paginationContainer.querySelector('.pagination-page-list');
            if (pageSizeSelect) {
                const handler = () => {
                    handlePageChange();
                };
                pageSizeSelect.addEventListener('change', handler);
                paginationHandlers.push({ element: pageSizeSelect, event: 'change', callback: handler });
            }
            
            // console.log('[表单详情抓取] 已设置分页按钮监听器');
        } catch (error) {
            // console.error('[表单详情抓取] 设置分页按钮监听时出错:', error);
        }
    }
    
    function observeTableChanges() {
        try {
            // 如果已经有观察者，先断开
            if (tableObserver) {
                tableObserver.disconnect();
                tableObserver = null;
            }
            
            const mainDoc = getMainDocument();
            
            // 尝试在主文档和iframe中查找表格
            let tableBody = mainDoc.querySelector('.datagrid-btable tbody');
            let targetDoc = mainDoc;
            
            if (!tableBody) {
                // 尝试在iframe中查找
                const iframes = mainDoc.querySelectorAll('iframe');
                for (const iframe of iframes) {
                    try {
                        const iframeDoc = iframe.contentDocument || iframe.contentWindow?.document;
                        if (iframeDoc) {
                            tableBody = iframeDoc.querySelector('.datagrid-btable tbody');
                            if (tableBody) {
                                targetDoc = iframeDoc;
                                break;
                            }
                        }
                    } catch (e) {
                        // 跨域iframe无法访问，跳过
                    }
                }
            }
            
            if (!tableBody) {
                // 如果表格还没加载，稍后重试
                setTimeout(() => {
                    if (isMyApplicationListPage()) {
                        observeTableChanges();
                    }
                }, 2000);
                return;
            }

            // 确保表头已添加（在"表单类型"列之后）
            addDetailsHeader(targetDoc);

            // 记录当前行数和行ID
            const currentRows = tableBody.querySelectorAll('tr.datagrid-row');
            lastRowCount = currentRows.length;
            lastRowIds.clear();
            currentRows.forEach(row => {
                const checkbox = row.querySelector('input[type="checkbox"][name="id"]');
                if (checkbox && checkbox.value) {
                    lastRowIds.add(checkbox.value);
                }
            });

            // 设置分页按钮监听
            observePaginationButtons(targetDoc);

            tableObserver = new MutationObserver((mutations) => {
                // 检查是否有变化
                let hasChanges = false;
                
                // 检查行数是否变化
                const currentRows = tableBody.querySelectorAll('tr.datagrid-row');
                const currentRowCount = currentRows.length;
                
                // 检查行ID是否变化（翻页时行ID会完全不同）
                const currentRowIds = new Set();
                currentRows.forEach(row => {
                    const checkbox = row.querySelector('input[type="checkbox"][name="id"]');
                    if (checkbox && checkbox.value) {
                        currentRowIds.add(checkbox.value);
                    }
                });
                
                // 如果行ID集合完全不同，说明是翻页了
                const rowIdsChanged = currentRowIds.size > 0 && 
                    (currentRowIds.size !== lastRowIds.size || 
                     !Array.from(currentRowIds).every(id => lastRowIds.has(id)));
                
                if (currentRowCount !== lastRowCount || rowIdsChanged) {
                    hasChanges = true;
                    lastRowCount = currentRowCount;
                    lastRowIds = currentRowIds;
                }
                
                // 检查是否有新行添加或删除
                mutations.forEach((mutation) => {
                    if (mutation.addedNodes.length > 0 || mutation.removedNodes.length > 0) {
                        mutation.addedNodes.forEach((node) => {
                            if (node.nodeType === 1 && (node.classList.contains('datagrid-row') || node.querySelector('.datagrid-row'))) {
                                hasChanges = true;
                            }
                        });
                        mutation.removedNodes.forEach((node) => {
                            if (node.nodeType === 1 && (node.classList.contains('datagrid-row') || node.querySelector('.datagrid-row'))) {
                                hasChanges = true;
                            }
                        });
                    }
                });

                if (hasChanges) {
                    // 延迟处理，确保DOM已完全更新，并且避免重复处理
                    setTimeout(() => {
                        if (!isProcessing) {
                            // 如果行ID集合完全不同，说明是翻页，清除所有已处理标记
                            if (rowIdsChanged && currentRowIds.size > 0) {
                                processedRows.clear();
                            }
                            processAllRows();
                        }
                    }, 500);
                }
            });

            tableObserver.observe(tableBody, {
                childList: true,
                subtree: true
            });

        } catch (error) {
            // console.error('[表单详情抓取] 监听表格变化时出错:', error);
        }
    }


    // 监听查询和清空按钮
    function observeQueryButtons(targetDoc) {
        try {
            const mainDoc = targetDoc || getMainDocument();
            
            // 查找查询区域的确定按钮（调用query()函数）
            // 使用多种选择器以确保能捕获到按钮
            const querySelectors = [
                'a[onclick*="query()"]',
                'a[onclick*="query();"]',
                '#search a[class*="icon-search"]',
                '.datagrid-toolbar a[class*="icon-search"]'
            ];
            
            querySelectors.forEach(selector => {
                const queryButtons = mainDoc.querySelectorAll(selector);
                queryButtons.forEach(btn => {
                    // 检查按钮文本是否包含"确定"
                    const btnText = btn.textContent || '';
                    if (btnText.includes('确定') || btn.getAttribute('onclick')?.includes('query')) {
                        const handler = (e) => {
                            // console.log('[表单详情抓取] 检测到查询按钮点击');
                            // 延迟处理，等待查询完成
                            setTimeout(() => {
                                handlePageChange();
                            }, 1000);
                        };
                        btn.addEventListener('click', handler);
                        paginationHandlers.push({ element: btn, event: 'click', callback: handler });
                    }
                });
            });
            
            // 查找清空按钮（调用requery()函数）
            const requerySelectors = [
                'a[onclick*="requery()"]',
                'a[onclick*="requery();"]',
                '#search a[class*="icon-cancel"]',
                '.datagrid-toolbar a[class*="icon-cancel"]'
            ];
            
            requerySelectors.forEach(selector => {
                const requeryButtons = mainDoc.querySelectorAll(selector);
                requeryButtons.forEach(btn => {
                    // 检查按钮文本是否包含"清空"
                    const btnText = btn.textContent || '';
                    if (btnText.includes('清空') || btn.getAttribute('onclick')?.includes('requery')) {
                        const handler = (e) => {
                            // console.log('[表单详情抓取] 检测到清空按钮点击');
                            // 延迟处理，等待清空并重新加载完成
                            setTimeout(() => {
                                handlePageChange();
                            }, 1000);
                        };
                        btn.addEventListener('click', handler);
                        paginationHandlers.push({ element: btn, event: 'click', callback: handler });
                    }
                });
            });
            
            // 使用事件委托监听查询区域的所有点击（更可靠）
            const searchArea = mainDoc.querySelector('#search');
            if (searchArea) {
                const handleSearchClick = (e) => {
                    const target = e.target;
                    const btn = target.closest('a');
                    if (btn) {
                        const btnText = btn.textContent || '';
                        const onclick = btn.getAttribute('onclick') || '';
                        
                        // 检查是否是查询或清空按钮
                        if (onclick.includes('query()') || onclick.includes('query();')) {
                            // console.log('[表单详情抓取] 检测到查询按钮点击（事件委托）');
                            setTimeout(() => {
                                handlePageChange();
                            }, 1000);
                        } else if (onclick.includes('requery()') || onclick.includes('requery();')) {
                            // console.log('[表单详情抓取] 检测到清空按钮点击（事件委托）');
                            setTimeout(() => {
                                handlePageChange();
                            }, 1000);
                        }
                    }
                };
                searchArea.addEventListener('click', handleSearchClick, true);
                paginationHandlers.push({ element: searchArea, event: 'click', callback: handleSearchClick });
            }
            
            // console.log('[表单详情抓取] 已设置查询/清空按钮监听器');
        } catch (error) {
            // console.error('[表单详情抓取] 设置查询/清空按钮监听时出错:', error);
        }
    }

    // 初始化
    async function init() {
        // 检查是否是"我的申请单"页面
        if (!isMyApplicationListPage()) {
            return;
        }

        // console.log('[表单详情抓取] 检测到"我的申请单"页面，开始初始化...');

        // 添加详情列表头（在"表单类型"列之后，包含刷新按钮）
        addDetailsHeader();

        // 处理现有数据
        await processAllRows();

        // 监听表格变化
        observeTableChanges();
        
        // 监听查询和清空按钮
        observeQueryButtons();
        
        // 启动定期检查
        startPeriodicCheck();
    }

    // 页面加载完成后初始化
    if (document.readyState === 'loading') {
        document.addEventListener('DOMContentLoaded', () => {
            setTimeout(init, 500);
        });
    } else {
        setTimeout(init, 500);
    }

    // 如果页面是动态加载的，定期检查（但不要太频繁）
    let lastProcessTime = 0;
    let checkInterval = null;
    
    function startPeriodicCheck() {
        // 如果已经有定时器，先清除
        if (checkInterval) {
            clearInterval(checkInterval);
        }
        
        checkInterval = setInterval(() => {
            if (isMyApplicationListPage()) {
                const now = Date.now();
                // 至少间隔30秒才重新处理
                if (!isProcessing && now - lastProcessTime > 30000) {
                    lastProcessTime = now;
                    // 重新处理
                    processAllRows().catch(err => {
                        // console.error('[表单详情抓取] 定期检查处理失败:', err);
                    });
                }
            } else {
                // 如果不是目标页面，清除定时器
                if (checkInterval) {
                    clearInterval(checkInterval);
                    checkInterval = null;
                }
            }
        }, 10000); // 每10秒检查一次
    }

})();

